// 引入puppeteer
const puppeteer = require('puppeteer');
const cheerio = require('cheerio');
const { createWorker } = require('tesseract.js');
// const tesseract = require("node-tesseract-ocr")
// const tesseract = require('node-tesr')
const tesseract = require('tesseractocr')
const fs = require('fs');
const fetch = require('node-fetch');
const { runPythonInNodeEnvSync } = require('./ocr/index')

const Ts = require('tesseract.js')

const {Jimp} = require('jimp');
const path = require('path');

const hideChrome = true
async function preprocessImage(imagePath) {
    console.log('开始预处理图像...',);
    
    // 使用Jimp加载并预处理图像
    const image = await Jimp.read(imagePath);
    // 转换为灰度图像
    image.greyscale().contrast(1).brightness(1);
    // 二值化
    image.threshold({
        max: 120,
        autoGreyscale: true
    });


    // 保存临时文件供Tesseract使用
    const tempImagePath = path.join(__dirname, 'temp', 'preprocessed.png');
    await image.write(tempImagePath);
    return tempImagePath;
}

async function sText(PathStr){
    let imagePath = PathStr
    imagePath = await preprocessImage(imagePath);
    console.log('加工之后的图片',imagePath);
    
    let { data: { text } } = await Ts.recognize( imagePath , 'eng',{
        // logger: m => console.log(m)
    })
    // 提取text里面的数字
    if(text && (/\d+/g).test(text) ){
        text = text.match(/\d+/g).join('');
        console.log('识别验证码:',text);
    }else {
        console.log('识别验证码:',text || '');
    }
    return text;
}

const config = {
    lang: "eng",
    psm: 4,
  }

// 调试模式配置
const DEBUG_MODE = true; // 设置为true开启调试模式
const DEBUG_DIR = path.join(__dirname, '../debug');

// Tesseract模型路径
const TESSERACT_LOCAL_PATH = path.join(__dirname, '../tessdata');

// 确保调试目录存在
if (DEBUG_MODE) {
    if (!fs.existsSync(DEBUG_DIR)) {
        fs.mkdirSync(DEBUG_DIR, { recursive: true });
        console.log('调试目录已创建:', DEBUG_DIR);
    }
}

// 确保Tesseract模型目录存在
if (!fs.existsSync(TESSERACT_LOCAL_PATH)) {
    fs.mkdirSync(TESSERACT_LOCAL_PATH, { recursive: true });
    console.log('Tesseract模型目录已创建:', TESSERACT_LOCAL_PATH);
}

// 控制台颜色
const consoleColors = {
    reset: "\x1b[0m",
    bright: "\x1b[1m",
    dim: "\x1b[2m",
    underscore: "\x1b[4m",
    blink: "\x1b[5m",
    reverse: "\x1b[7m",
    hidden: "\x1b[8m",
    
    black: "\x1b[30m",
    red: "\x1b[31m",
    green: "\x1b[32m",
    yellow: "\x1b[33m",
    blue: "\x1b[34m",
    magenta: "\x1b[35m",
    cyan: "\x1b[36m",
    white: "\x1b[37m",
    
    bgBlack: "\x1b[40m",
    bgRed: "\x1b[41m",
    bgGreen: "\x1b[42m",
    bgYellow: "\x1b[43m",
    bgBlue: "\x1b[44m",
    bgMagenta: "\x1b[45m",
    bgCyan: "\x1b[46m",
    bgWhite: "\x1b[47m"
};

class SkipCaptcha {
    constructor(){
        this.browser = null;
        this.retryCount = 0; // 重试计数器
        this.maxRetries = 3; // 最大重试次数
        this.captchaError = false; // 验证码错误标志
        
        // 确保在进程退出时关闭所有浏览器实例
        process.on('exit', async () => {
            if (this.browser) {
                try {
                    await this.browser.close();
                    this.browser = null;
                } catch (error) {
                    console.error('关闭浏览器时出错:', error);
                }
            }
        });
        
        // 捕获未处理的异常，确保关闭浏览器
        process.on('uncaughtException', async (error) => {
            console.error('未捕获的异常:', error);
            if (this.browser) {
                try {
                    await this.browser.close();
                    this.browser = null;
                } catch (closeError) {
                    console.error('关闭浏览器时出错:', closeError);
                }
            }
            process.exit(1);
        });
    }

    /**
     * @name saveDebugInfo
     * @description 保存调试信息到文件
     * @param {string} type 信息类型
     * @param {string} data 要保存的数据
     */
    saveDebugInfo(type, data) {
        if (!DEBUG_MODE) return;
        
        const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
        let filePath;
        
        if (type === 'captcha_image') {
            // 保存验证码图片
            filePath = path.join(DEBUG_DIR, `captcha_${timestamp}.png`);
            // 去掉base64前缀
            const base64Data = data.replace(/^data:image\/\w+;base64,/, '');
            fs.writeFileSync(filePath, base64Data, 'base64');
        } else if (type === 'html') {
            // 保存HTML内容
            filePath = path.join(DEBUG_DIR, `page_${timestamp}.html`);
            fs.writeFileSync(filePath, data);
        } else if (type === 'log') {
            // 保存日志信息
            filePath = path.join(DEBUG_DIR, `log_${timestamp}.txt`);
            fs.writeFileSync(filePath, data);
        }
        
        console.log(`调试信息已保存到: ${filePath}`);
        return filePath
    }

    /**
     * @name recognizeCaptcha
     * @description 使用OCR识别验证码
     * @param {string} base64Image 验证码图片的base64编码
     * @returns {Promise<string>} 识别出的验证码文本
     */
    async recognizeCaptcha(base64Image) {
        try {
            console.log('开始识别验证码...');
            
            // 保存验证码图片用于调试
            let caPath = this.saveDebugInfo('captcha_image', base64Image);

            console.log('图片路径',caPath);

            let result = runPythonInNodeEnvSync(caPath)
            
            console.log('识别结果',result);
            result = JSON.parse(result)
            return result.code
        } catch (error) {
            
            console.error(`${consoleColors.red}验证码识别失败:${consoleColors.reset}`, error);
            // this.saveDebugInfo('log', `验证码识别失败: ${error.message}`);
            
            // 如果OCR识别失败，返回一个可能的验证码（通常是4-6位数字或字母）
            // 这是一个后备方案，可能不准确，但至少可以尝试
            const possibleCaptcha = this.generateRandomCaptcha();
            console.log(`${consoleColors.yellow}OCR识别失败，使用随机生成的验证码: ${possibleCaptcha}${consoleColors.reset}`);
            return possibleCaptcha;
        }
    }
    
    /**
     * @name generateRandomCaptcha
     * @description 生成一个随机的验证码字符串（用于OCR失败时的后备方案）
     * @returns {string} 随机验证码
     */
    generateRandomCaptcha() {
        const chars = '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ';
        const length = Math.floor(Math.random() * 3) + 4; // 4-6位
        let result = '';
        for (let i = 0; i < length; i++) {
            result += chars.charAt(Math.floor(Math.random() * chars.length));
        }
        return result;
    }

    /**
     * @name autoHandleCaptcha
     * @description 自动处理验证码并搜索
     * @param {string} searchPath 搜索的影视地址
     * @param {string} keyword 搜索关键词
     * @returns {Promise<string>} 返回处理后的页面HTML内容
     */
    async autoHandleCaptcha(searchPath, keyword) {
        console.log(`${consoleColors.cyan}自动处理验证码开始, 搜索关键词:${consoleColors.reset}`, keyword);
        searchPath = searchPath || 'https://www.kanyikanys.cc/index.php?m=vod-search';
        
        // 重置重试计数器
        this.retryCount = 0;
        
        return this._handleCaptcha(searchPath, keyword);
    }
    
    /**
     * @name _handleCaptcha
     * @description 内部方法，处理验证码逻辑
     * @param {string} searchPath 搜索的影视地址
     * @param {string} keyword 搜索关键词
     * @returns {Promise<string>} 返回处理后的页面HTML内容
     */
    async _handleCaptcha(searchPath, keyword) {
        try {
            // 创建可见浏览器
            this.browser = await puppeteer.launch({
                headless: hideChrome,
                executablePath: 'C:/Program Files/Google/Chrome/Application/chrome.exe',
                args: ['--no-sandbox', '--disable-setuid-sandbox'],
                defaultViewport: null // 使用默认视口大小
            });
            
            const page = await this.browser.newPage();
            
            // 设置视口大小
            await page.setViewport({ width: 1280, height: 800 });
            
            // 监听页面的对话框事件（alert、confirm、prompt）
            page.on('dialog', async (dialog) => {
                console.log(`${consoleColors.yellow}检测到弹窗: ${dialog.message()}${consoleColors.reset}`);
                
                // 保存弹窗信息到日志
                // this.saveDebugInfo('log', `检测到弹窗: ${dialog.message()}`);
                
                // 接受对话框（点击确定）
                await dialog.accept();
                
                // 标记验证码错误
                this.captchaError = true;
            });
            
            // 导航到搜索页面
            console.log(`${consoleColors.cyan}正在导航到搜索页面:${consoleColors.reset}`, searchPath);
            await page.goto(searchPath, { waitUntil: 'networkidle2', timeout: 1500 });
            
            // 等待页面加载完成
            await page.waitForSelector('body', { timeout: 10000 });
            
            // 截图整个页面
            const initialScreenshotPath = path.join(DEBUG_DIR, `initial_page_${Date.now()}.png`);
            await page.screenshot({ path: initialScreenshotPath, fullPage: true });
            console.log(`初始页面截图已保存到: ${initialScreenshotPath}`);
            
            // 保存页面内容用于调试
            const initialHtml = await page.content();
            // this.saveDebugInfo('html', initialHtml);
            
            // 检查是否有验证码输入框
            const hasCaptcha = await page.evaluate(() => {
                return document.querySelector('input[name="verify"]') !== null;
            });
            
            if (hasCaptcha) {
                console.log(`${consoleColors.yellow}检测到验证码，准备截图并识别${consoleColors.reset}`);
                
                // 获取验证码图片
                const captchaImgSelector = 'img[class="mac_verify_img"]';
                try {
                    await page.waitForSelector(captchaImgSelector, { timeout: 5000 });
                } catch (error) {
                    console.error(`${consoleColors.red}未找到验证码图片元素:${consoleColors.reset}`, error);
                    
                    // 尝试查找其他可能的验证码图片选择器
                    const possibleSelectors = [
                        'img[src*="verify"]',
                        'img[src*="captcha"]',
                        '.captcha img',
                        '#captcha img',
                        'img[alt="captcha"]'
                    ];
                    
                    let foundSelector = false;
                    for (const selector of possibleSelectors) {
                        const exists = await page.$(selector);
                        if (exists) {
                            console.log(`${consoleColors.green}找到验证码图片，使用选择器:${consoleColors.reset} ${selector}`);
                            foundSelector = selector;
                            break;
                        }
                    }
                    
                    if (!foundSelector) {
                        // 如果找不到验证码图片，截图整个页面以便检查
                        const errorScreenshotPath = path.join(DEBUG_DIR, `error_no_captcha_${Date.now()}.png`);
                        await page.screenshot({ path: errorScreenshotPath, fullPage: true });
                        console.log(`${consoleColors.red}未找到验证码图片，页面截图已保存到:${consoleColors.reset} ${errorScreenshotPath}`);
                        throw new Error('未找到验证码图片元素');
                    }
                }
                
                // 截取验证码区域的截图
                const captchaAreaScreenshotPath = path.join(DEBUG_DIR, `captcha_area_${Date.now()}.png`);
                
                // 获取验证码图片元素的位置和大小
                const captchaElement = await page.$(captchaImgSelector);
                const boundingBox = await captchaElement.boundingBox();
                
                // 截图验证码区域（稍微扩大一点区域）
                await page.screenshot({
                    path: captchaAreaScreenshotPath,
                    clip: {
                        x: Math.max(0, boundingBox.x - 20),
                        y: Math.max(0, boundingBox.y - 20),
                        width: boundingBox.width + 40,
                        height: boundingBox.height + 40
                    }
                });
                console.log(`验证码区域截图已保存到: ${captchaAreaScreenshotPath}`);
                
                // 截取验证码图片
                const captchaBase64 = await captchaElement.screenshot({ encoding: 'base64' });
                
                // 使用OCR识别验证码
                const captchaCode = await this.recognizeCaptcha('data:image/png;base64,' + captchaBase64);
                


                if (!captchaCode) {
                    // throw new Error('验证码识别失败');
                    console.log('验证码识别失败');
                    return null;
                }
                
                console.log(`${consoleColors.green}验证码识别成功:${consoleColors.reset} ${captchaCode}`);
                
                // 输入搜索关键词
                // await page.type('input[name="wd"]', keyword);
                
                // 输入验证码
                await page.type('input[name="verify"]', captchaCode);
                
                // 截图提交前的页面状态
                const beforeSubmitPath = path.join(DEBUG_DIR, `before_submit_${Date.now()}.png`);
                await page.screenshot({ path: beforeSubmitPath, fullPage: true });
                console.log(`提交前页面截图已保存到: ${beforeSubmitPath}`);
                
                // 重置验证码错误标志
                this.captchaError = false;
                
                // 使用页面评估来提交表单，而不是直接点击按钮
                await page.evaluate(() => {
                    const submitButton = document.querySelector('input[type="submit"]') || 
                                        document.querySelector('button[type="submit"]') || 
                                        document.querySelector('.submit_btn') ||
                                        document.querySelector('input[value="提交验证"]');
                    
                    if (submitButton) {
                        console.log('找到提交按钮:', submitButton);
                        submitButton.click();
                    } else {
                        console.log('未找到提交按钮，尝试直接提交表单');
                        // 如果找不到提交按钮，尝试直接提交表单
                        const form = document.querySelector('form');
                        if (form) {
                            form.submit();
                        } else {
                            console.error('未找到表单元素');
                        }
                    }
                });
                
                // 等待一段时间，让可能的对话框有时间显示
                await new Promise(resolve => setTimeout(resolve, 500));
                
                // 检查是否有验证码错误弹窗
                if (this.captchaError) {
                    console.log(`${consoleColors.yellow}验证码输入错误，准备重新获取验证码${consoleColors.reset}`);
                    
                    // 尝试刷新验证码图片
                    try {
                        // 查找验证码刷新按钮或图片本身（点击图片通常也会刷新验证码）
                        const refreshSelector = 'a[href*="verify"]';
                        const refreshButton = await page.$(refreshSelector);
                        
                        if (refreshButton) {
                            console.log(`${consoleColors.green}找到验证码刷新按钮，点击刷新${consoleColors.reset}`);
                            await refreshButton.click();
                        } else {
                            // 如果没有刷新按钮，尝试点击验证码图片本身
                            const captchaImgSelector = 'img[class="mac_verify_img"]';
                            const captchaImg = await page.$(captchaImgSelector);
                            
                            if (captchaImg) {
                                console.log(`${consoleColors.green}点击验证码图片以刷新${consoleColors.reset}`);
                                await captchaImg.click();
                            } else {
                                // 如果找不到验证码图片，尝试刷新页面
                                console.log(`${consoleColors.yellow}未找到验证码刷新方式，刷新整个页面${consoleColors.reset}`);
                                await page.reload({ waitUntil: 'networkidle2' });
                            }
                        }
                        
                        // 等待验证码图片加载
                        await new Promise(resolve => setTimeout(resolve, 500));
                        
                        // 获取新的验证码图片并重新识别
                        const captchaImgSelector = 'img[class="mac_verify_img"]';
                        const captchaElement = await page.$(captchaImgSelector);
                        
                        if (captchaElement) {
                            // 截取新的验证码图片
                            const newCaptchaBase64 = await captchaElement.screenshot({ encoding: 'base64' });
                            
                            // 使用OCR识别新验证码
                            const newCaptchaCode = await this.recognizeCaptcha('data:image/png;base64,' + newCaptchaBase64);
                            
                            if (newCaptchaCode) {
                                console.log(`${consoleColors.green}新验证码识别成功:${consoleColors.reset} ${newCaptchaCode}`);
                                
                                // 清空验证码输入框
                                await page.evaluate(() => {
                                    const verifyInput = document.querySelector('input[name="verify"]');
                                    if (verifyInput) {
                                        verifyInput.value = '';
                                    }
                                });
                                
                                // 输入新验证码
                                await page.type('input[name="verify"]', newCaptchaCode);
                                
                                // 重新提交表单
                                await page.evaluate(() => {
                                    const submitButton = document.querySelector('input[type="submit"]') || 
                                                        document.querySelector('button[type="submit"]') || 
                                                        document.querySelector('.submit_btn') ||
                                                        document.querySelector('input[value="提交验证"]');
                                    
                                    if (submitButton) {
                                        submitButton.click();
                                    } else {
                                        const form = document.querySelector('form');
                                        if (form) {
                                            form.submit();
                                        }
                                    }
                                });
                            }
                        }
                    } catch (refreshError) {
                        console.error(`${consoleColors.red}刷新验证码时出错:${consoleColors.reset}`, refreshError);
                    }
                }
                
                // try {
                //     // 等待页面加载完成，使用更宽松的 networkidle2 条件
                //     await page.waitForNavigation({ waitUntil: 'networkidle2', timeout: 1500 });
                //     console.log(`${consoleColors.green}页面导航完成${consoleColors.reset}`);
                // } catch (navError) {
                //     console.error(`${consoleColors.red}等待页面导航超时:${consoleColors.reset}`, navError.message);
                //     console.log(`${consoleColors.yellow}导航超时，但继续处理页面内容${consoleColors.reset}`);
                //     // 在导航超时的情况下，给页面一些额外时间加载
                //     await new Promise(resolve => setTimeout(resolve, 3000));
                // }
                await new Promise(resolve => setTimeout(resolve, 500));
                // 获取页面内容
                const content = await page.content();
                // this.saveDebugInfo('html', content);
                
                // 截图提交后的页面状态
                const afterSubmitPath = path.join(DEBUG_DIR, `after_submit_${Date.now()}.png`);
                await page.screenshot({ path: afterSubmitPath, fullPage: true });
                console.log(`提交后页面截图已保存到: ${afterSubmitPath}`);
                
                // 检查是否还需要验证码（验证码识别错误）
                if (content.includes('系统安全验证')) {
                    console.log(`${consoleColors.yellow}验证码识别错误，尝试重新识别${consoleColors.reset}`);
                    
                    // 关闭当前浏览器
                    await this.browser.close();
                    this.browser = null;
                    
                    // 增加重试计数
                    this.retryCount++;
                    
                    // 检查是否超过最大重试次数
                    if (this.retryCount >= this.maxRetries) {
                        throw new Error(`验证码识别失败，已达到最大重试次数(${this.maxRetries})`);
                    }
                    
                    console.log(`${consoleColors.cyan}第${this.retryCount}次重试...${consoleColors.reset}`);
                    
                    // 递归调用，重试
                    return this._handleCaptcha(searchPath, keyword);
                }
                
                // 关闭浏览器
                await this.browser.close();
                this.browser = null;
                
                return content;
            } else {
                console.log(`${consoleColors.green}未检测到验证码输入框${consoleColors.reset}`);
                
                // 直接搜索
                await page.type('input[name="wd"]', keyword);
                
                // 截图提交前的页面状态
                const beforeSubmitPath = path.join(DEBUG_DIR, `before_submit_no_captcha_${Date.now()}.png`);
                await page.screenshot({ path: beforeSubmitPath, fullPage: true });
                console.log(`提交前页面截图已保存到: ${beforeSubmitPath}`);
                



                // 使用页面评估来提交表单
                await page.evaluate(async () => {
                    const submitButton = document.querySelector('input[type="submit"]') || 
                                        document.querySelector('button[type="submit"]');
                    
                    if (submitButton) {
                        submitButton.click();

                        // 点击之后如果页面alert，则是验证码输入错误 则重新尝试输入
                        // puppeteer查看页面是否有alert
                        const hasAlert = await page.evaluate(() => {
                            return window.alert !== undefined;
                        });
                        if (hasAlert) {
                            console.log('验证码输入错误，请重新输入， 正在准备执行清楚输入框')
                            // 点击alert上面的确定
                            

                            // await page.reload();
                            // await page.waitForSelector('input[type="text"]');
                            // await page.type('input[type="text"]', captcha);
                            // await page.click('input[type="submit"]');
                        }
                    } else {
                        // 如果找不到提交按钮，尝试直接提交表单
                        const form = document.querySelector('form');
                        if (form) {
                            form.submit();
                        }
                    }
                });
                
                // try {
                //     // 等待页面加载完成，使用更宽松的 networkidle2 条件
                //     await page.waitForNavigation({ waitUntil: 'networkidle2', timeout: 500 });
                //     console.log(`${consoleColors.green}页面导航完成${consoleColors.reset}`);
                // } catch (navError) {
                //     console.error(`${consoleColors.red}等待页面导航超时:${consoleColors.reset}`, navError.message);
                //     console.log(`${consoleColors.yellow}导航超时，但继续处理页面内容${consoleColors.reset}`);
                //     // 在导航超时的情况下，给页面一些额外时间加载
                //     await new Promise(resolve => setTimeout(resolve, 500));
                // }

                await new Promise(resolve => setTimeout(resolve, 500));
                
                
                // 获取页面内容
                const content = await page.content();
                // this.saveDebugInfo('html', content);
                
                // 截图提交后的页面状态
                const afterSubmitPath = path.join(DEBUG_DIR, `after_submit_no_captcha_${Date.now()}.png`);
                await page.screenshot({ path: afterSubmitPath, fullPage: true });
                console.log(`提交后页面截图已保存到: ${afterSubmitPath}`);
                
                // 关闭浏览器
                await this.browser.close();
                this.browser = null;
                
                return content;
            }
        } catch (error) {
            console.error(`${consoleColors.bgRed}${consoleColors.white}自动处理验证码过程中出错:${consoleColors.reset}`, error);
            // this.saveDebugInfo('log', `自动处理验证码过程中出错: ${error.message}`);
            
            if (this.browser) {
                try {
                    // 错误发生时截图
                    const page = (await this.browser.pages())[0];
                    if (page) {
                        const errorScreenshotPath = path.join(DEBUG_DIR, `error_${Date.now()}.png`);
                        await page.screenshot({ path: errorScreenshotPath, fullPage: true });
                        console.log(`错误页面截图已保存到: ${errorScreenshotPath}`);
                    }
                    
                    await this.browser.close();
                } catch (closeError) {
                    console.error(`${consoleColors.red}关闭浏览器时出错:${consoleColors.reset}`, closeError);
                }
                this.browser = null;
            }
            throw error;
        }
    }

    /**
     * @param {string} searchPath 搜索的影视地址
     * @param {string} keyword 搜索关键词
     * @param {string} captchaCode 验证码
     * @returns {Promise<string>} 返回处理后的页面HTML内容
     * */ 
    async getCaptcha(searchPath, keyword, captchaCode){
        console.log('验证码地址::::>', searchPath);
        searchPath = searchPath || 'https://www.kanyikanys.cc/index.php?m=vod-search';
        
        try {
            // 创建可见浏览器
            this.browser = await puppeteer.launch({
                headless: false,
                executablePath: 'C:/Program Files/Google/Chrome/Application/chrome.exe',
            });
            
            const page = await this.browser.newPage();
            await page.goto(searchPath);
            
            // 检查是否有验证码输入框
            const hasCaptcha = await page.evaluate(() => {
                return document.querySelector('input[name="verify"]') !== null;
            });
            
            if (hasCaptcha && captchaCode) {
                // 输入搜索关键词
                await page.type('input[name="wd"]', keyword);
                
                // 输入验证码
                await page.type('input[name="verify"]', captchaCode);
                
                // 点击提交按钮
                await page.click('input[type="submit"]');
                
                // 等待页面加载完成
                // try {
                //     await page.waitForNavigation({ waitUntil: 'networkidle2', timeout: 1500 });
                //     console.log(`${consoleColors.green}页面导航完成${consoleColors.reset}`);
                // } catch (navError) {
                //     console.error(`${consoleColors.red}等待页面导航超时:${consoleColors.reset}`, navError.message);
                //     console.log(`${consoleColors.yellow}导航超时，但继续处理页面内容${consoleColors.reset}`);
                //     // 在导航超时的情况下，给页面一些额外时间加载
                //     await new Promise(resolve => setTimeout(resolve, 3000));
                // }
                await new Promise(resolve => setTimeout(resolve, 500));

                
                // 获取页面内容
                const content = await page.content();
                
                // 关闭浏览器
                await this.browser.close();
                this.browser = null;
                
                return content;
            } else {
                console.log('没有找到验证码输入框或未提供验证码');
                await this.browser.close();
                this.browser = null;
                return null;
            }
        } catch (error) {
            console.error('处理验证码过程中出错:', error);
            if (this.browser) {
                await this.browser.close();
                this.browser = null;
            }
            throw error;
        }
    }
    
    /**
     * @param {string} searchPath 搜索的影视地址
     * @returns {Promise<string>} 返回验证码图片的base64编码
     */
    async getCaptchaImage(searchPath) {
        console.log('获取验证码图片::::>', searchPath);
        searchPath = searchPath || 'https://www.kanyikanys.cc/index.php?m=vod-search';
        
        try {
            // 创建可见浏览器
            this.browser = await puppeteer.launch({
                headless: false,
                executablePath: 'C:/Program Files/Google/Chrome/Application/chrome.exe',
            });
            
            const page = await this.browser.newPage();
            await page.goto(searchPath);
            
            // 检查是否有验证码图片
            const captchaImgSelector = 'img[class="mac_verify_img"]';
            try {
                await page.waitForSelector(captchaImgSelector, { timeout: 5000 });
            } catch (error) {
                console.error(`${consoleColors.red}未找到验证码图片元素:${consoleColors.reset}`, error);
                
                // 尝试查找其他可能的验证码图片选择器
                const possibleSelectors = [
                    'img[src*="verify"]',
                    'img[src*="captcha"]',
                    '.captcha img',
                    '#captcha img',
                    'img[alt="captcha"]'
                ];
                
                let foundSelector = false;
                for (const selector of possibleSelectors) {
                    const exists = await page.$(selector);
                    if (exists) {
                        console.log(`${consoleColors.green}找到验证码图片，使用选择器:${consoleColors.reset} ${selector}`);
                        foundSelector = selector;
                        break;
                    }
                }
                
                if (!foundSelector) {
                    // 如果找不到验证码图片，截图整个页面以便检查
                    const errorScreenshotPath = path.join(DEBUG_DIR, `error_no_captcha_${Date.now()}.png`);
                    await page.screenshot({ path: errorScreenshotPath, fullPage: true });
                    console.log(`${consoleColors.red}未找到验证码图片，页面截图已保存到:${consoleColors.reset} ${errorScreenshotPath}`);
                    throw new Error('未找到验证码图片元素');
                }
            }
            
            // 获取验证码图片的base64编码
            const captchaBase64 = await page.evaluate((selector) => {
                const img = document.querySelector(selector);
                if (!img) return null;
                
                // 创建canvas来获取图片数据
                const canvas = document.createElement('canvas');
                canvas.width = img.width;
                canvas.height = img.height;
                const ctx = canvas.getContext('2d');
                ctx.drawImage(img, 0, 0);
                
                // 返回base64编码
                return canvas.toDataURL('image/png');
            }, captchaImgSelector);
            
            // 不关闭浏览器，后续需要用来输入验证码
            return { 
                captchaBase64,
                page
            };
        } catch (error) {
            console.error('获取验证码图片过程中出错:', error);
            if (this.browser) {
                await this.browser.close();
                this.browser = null;
            }
            throw error;
        }
    }
    
    /**
     * @param {object} page puppeteer页面对象
     * @param {string} keyword 搜索关键词
     * @param {string} captchaCode 验证码
     * @returns {Promise<string>} 返回处理后的页面HTML内容
     */
    async submitCaptcha(page, keyword, captchaCode) {
        try {
            if (!page) {
                throw new Error('页面对象不存在');
            }
            
            // 重置验证码错误标志
            this.captchaError = false;
            
            // 监听页面的对话框事件（alert、confirm、prompt）
            page.on('dialog', async (dialog) => {
                console.log(`${consoleColors.yellow}检测到弹窗: ${dialog.message()}${consoleColors.reset}`);
                
                // 保存弹窗信息到日志
                // this.saveDebugInfo('log', `检测到弹窗: ${dialog.message()}`);
                
                // 接受对话框（点击确定）
                await dialog.accept();
                
                // 标记验证码错误
                this.captchaError = true;
            });
            
            // 输入搜索关键词
            await page.type('input[name="wd"]', keyword);
            
            // 输入验证码
            await page.type('input[name="verify"]', captchaCode);
            
            // 点击提交按钮
            await page.click('input[type="submit"]');
            
            // 等待一段时间，让可能的对话框有时间显示
            await new Promise(resolve => setTimeout(resolve, 2000));
            
            // 检查是否有验证码错误弹窗
            if (this.captchaError) {
                console.log(`${consoleColors.yellow}验证码输入错误，需要重新获取验证码${consoleColors.reset}`);
                
                // 返回错误状态，让调用者知道需要重新获取验证码
                return { error: true, message: '验证码输入错误' };
            }
            
            // try {
            //     // 等待页面加载完成，使用更宽松的 networkidle2 条件
            //     await page.waitForNavigation({ waitUntil: 'networkidle2', timeout: 1500 });
            //     console.log(`${consoleColors.green}页面导航完成${consoleColors.reset}`);
            // } catch (navError) {
            //     console.error(`${consoleColors.red}等待页面导航超时:${consoleColors.reset}`, navError.message);
            //     console.log(`${consoleColors.yellow}导航超时，但继续处理页面内容${consoleColors.reset}`);
            //     // 在导航超时的情况下，给页面一些额外时间加载
            //     await new Promise(resolve => setTimeout(resolve, 500));
            // }

            await new Promise(resolve => setTimeout(resolve, 500));

            // 获取页面内容
            const content = await page.content();
            
            // 关闭浏览器
            if (this.browser) {
                await this.browser.close();
                this.browser = null;
            }
            
            return { content, error: false };
        } catch (error) {
            console.error('提交验证码过程中出错:', error);
            if (this.browser) {
                await this.browser.close();
                this.browser = null;
            }
            throw error;
        }
    }
}

module.exports = SkipCaptcha